/*=============================================================================
D3DPostProcess : Direct3D specific post processing special effects
Copyright (c) 2001 Crytek Studios. All Rights Reserved.

Revision history:
* 23/02/2005: Re-factored/Converted to CryEngine 2.0 by Tiago Sousa
* Created by Tiago Sousa

Todo:
* Erradicate StretchRect usage
* Cleanup code
* When we have a proper static branching support use it instead of shader switches inside code

=============================================================================*/

#include "StdAfx.h"
#include "NULL_Renderer.h"
#include "I3DEngine.h"
#include "../Common/PostProcess/PostEffects.h"

/////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////

void CDepthOfField::Render()
{
}

CMotionBlur::OMBParamsMap CMotionBlur::m_pOMBData[3];

bool CMotionBlur::Preprocess()
{
  return true;
}
void CMotionBlur::Render()
{
}

void CMotionBlur::SetupObject( CRenderObject *pObj )
{
}

const Matrix34A& CMotionBlur::GetPrevObjToWorldMat( CRenderObject *pObj )
{
	static Matrix34A mat = Matrix34A::CreateIdentity();
	return mat;
}

void CMotionBlur::OnBeginFrame()
{
}


bool CSunShafts::Preprocess()
{
  return true;
}

void CSunShafts::Render() 
{
}


void CFilterSharpening::Render()
{
}
void CFilterBlurring::Render()
{
}


void CUnderwaterGodRays::Render()
{
}

void CVolumetricScattering::Render()
{
}

void CWaterDroplets::Render()
{
}

void CWaterFlow::Render()
{


}


void CWaterRipples::AddHit(const Vec3 &vPos)
{

}

bool CWaterRipples::Preprocess()
{
	return true;
}

void CWaterRipples::Reset(bool bOnSpecChange)
{
}

void CWaterRipples::Render()
{
}

void CScreenFrost::Render()
{
}

bool CRainDrops::Preprocess()
{
  return true;
}
void CRainDrops::Render()
{
}

bool CNightVision::Preprocess()
{
  return true;
}

void CNightVision::Render()
{
}

bool CFlashBang::Preprocess()
{
  return true;
}

void CFlashBang::Render()
{
}
void CGlow::Render() 
{
}

void CAlienInterference::Render()
{
}

void CHudSilhouettes::Render()
{
}

void CColorGrading::Render()
{

}

void CWaterVolume::Render()
{

}

void CGammaReference::Render()
{

}


void CSceneRain::CreateBuffers( uint16 nVerts, void *&pINpVB, SVF_P3F_C4B_T2F *pVtxList)
{

}

int CSceneRain::CreateResources()
{

  return 1;
}

void CSceneRain::Release()
{

}

void CSceneRain::Render()
{

}


bool CSceneSnow::Preprocess()
{
  return true;
}
void CSceneSnow::Render()
{
}

int CSceneSnow::CreateResources()
{
	return 1;
}

void CSceneSnow::Release()
{
}

bool CPostAA::Preprocess()
{
	return true;
}

void CPostAA::Render()
{

}

bool CPostStereo::Preprocess()
{
	return true;
}

void CPostStereo::Render()
{

}

void C3DHud::SHudData::Init()
{

}

void C3DHud::SHudData::Release()
{

}

int C3DHud::CreateResources()
{
	return 1;
}

void C3DHud::Release()
{

}

void C3DHud::Render(void)
{

}

void C3DHud::Reset(bool bOnSpecChange)
{

}

void C3DHud::AddRE(const CRendElementBase* re, const SShaderItem* pShaderItem, CRenderObject* pObj)
{

}

bool C3DHud::Preprocess()
{
	return true;
}

bool CSonarVision::Preprocess()
{
	return false;
}

void CSonarVision::Render()
{

}

void CThermalVision::Render()
{

}

bool CThermalVision::Preprocess()
{
	return false;
}

void CImageGhosting::Render()
{

}

void CFilterKillCamera::Render()
{
}

void CUberGamePostProcess::Render()
{

}

void CNanoGlass::Render()
{
}

void CSoftAlphaTest::Render()
{
}


void CHUDHitEffect::Render()
{
}

void CHUDHitEffect::Update()
{
}

void CScreenBlood::Render() { }

void CScreenGlassShards::Render() { }

void CPost3DRenderer::Render()
{
}

/////////////////////////////////////////////////////////////////////////////////////////////////////


namespace WaterVolumeStaticData
{
	void GetMemoryUsage( ICrySizer *pSizer ){}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////

bool CSceneRain::Preprocess() { return true; }
//void CSceneRain::Render() {}
void CSceneRain::Reset(bool bOnSpecChange) {}
void CSceneRain::OnLostDevice() {}

const char *CSceneRain::GetName() const {return 0;}
const char *CRainDrops::GetName() const {return 0;}

/////////////////////////////////////////////////////////////////////////////////////////////////////

void CSceneSnow::Reset(bool bOnSpecChange) {}


const char *CSceneSnow::GetName() const {return 0;}

/////////////////////////////////////////////////////////////////////////////////////////////////////

bool CREPostProcess::mfDraw(CShader *ef, SShaderPass *sfm)
{      
  return true;
}


/////////////////////////////////////////////////////////////////////////////////////////////////////

void CPostEffect::DrawGeometry(SRenderDataAr* pRenderDataAr, CShader* pShader, const CCryNameTSCRC& nameTech)
{

}


//////////////////////////////////////////////////////////////////////////

int CScreenFog::CreateResources()
{
	return 0;
}

void CScreenFog::Release()
{
}

void CScreenFog::Render()
{
}

void CScreenFog::Update()
{
}


/////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////
